package com.quyunshuo.module.home.activity.main

import android.util.Log
import androidx.lifecycle.viewModelScope
import com.quyunshuo.androidbaseframemvvm.base.mvvm.vm.BaseViewModel
import com.quyunshuo.module.home.data.CoffeeProduct
import com.quyunshuo.module.home.room.database.SumDataBase
import com.quyunshuo.module.home.room.entity.PoetEntity
import com.quyunshuo.module.home.room.manager.PoetRepository
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.withContext
import javax.inject.Inject

/**
 * 首页的VM层
 *
 * @property mRepository HomeRepository 仓库层 通过Hilt注入
 *
 * @author Qu Yunshuo
 * @since 5/25/21 5:41 PM
 */
 @HiltViewModel
class HomeViewModel @Inject constructor(private val mRepository: HomeRepository) : BaseViewModel() {

    private val coffeeList =  CoffeeProduct.coffeeList

    fun getAllList()= coffeeList

    // 使用MutableStateFlow来存储咖啡列表，初始值为空列表
    private val _coffeeCarList = MutableStateFlow<List<CoffeeProduct>>(emptyList())
    val coffeeCarList = _coffeeCarList.asStateFlow()


    // 计算总价的状态流
    val totalPrice: StateFlow<Double> = coffeeCarList
        .map { list ->
            // 计算购物车中所有商品的总价
            list.sumOf { it.price }
        }
        .stateIn(//会启动监听。
            scope = viewModelScope, // 绑定到 ViewModel 的生命周期
            started = SharingStarted.WhileSubscribed(5000), // 优化: 保持活跃订阅状态
            initialValue = 0.0 // 初始值为 0
        )


    fun getCoffeeListIndex(position:Int) : CoffeeProduct? {
        if (position<0  || position>=coffeeList.size) {
            return null
        }
        return coffeeList[position]
    }

    // 伪代码揭示风险：如果 ​​多个线程同时执行上述操作​​： 线程A 写入 [A, B]
    //线程B 写入 [A, C] 👉 ​​丢失更新​​！添加的 B 被覆盖
//    fun addCoffeeCar(product: CoffeeProduct) {
//        val current = _coffeeCarList.value // 1. 读取当前值
//        val updated = current + product    // 2. 创建新集合
//        _coffeeCarList.value = updated     // 3. 写入新值
//    }

    fun addCoffeeCar(coffeeProduct: CoffeeProduct?) {
        // 创建新列表并添加元素 todo 线程安全的，
//        val newList = _coffeeCarList.value.toMutableList().apply {
//            if (coffeeProduct != null) {
//                add(coffeeProduct)
//            }
//        }
//        _coffeeCarList.value = newList
        coffeeProduct?.let { product ->
            //我的核心述求：往列表里添加数据，并触发更新，让别人监听到。
            _coffeeCarList.update { currentList -> //currentList它是 _coffeeCarList 的​​当前值​​
                currentList + product//+操作符对集合的作用：创建​​新列表​​（原列表不变，符合不可变编程规范）
            }
            /*
            // 假设初始状态
                _coffeeCarList.value = [拿铁, 卡布奇诺]

                // 当执行 update 时：
                _coffeeCarList.update { currentList ->  // currentList = [拿铁, 卡布奇诺]
                    currentList + "摩卡"                // 创建新列表 [拿铁, 卡布奇诺, 摩卡]
                }

                // 最终结果：
                _coffeeCarList.value = [拿铁, 卡布奇诺, 摩卡]
             */
        }
    }
    // 添加互斥锁
    private val mutex = Mutex()
    fun addCoffeeCar1(coffeeProduct: CoffeeProduct?) {
        viewModelScope.launch {
            var coff = withContext(Dispatchers.IO){
                coffeeProduct?.let { product ->
                    mutex.withLock {
                        // 现在整个操作是原子的
                        _coffeeCarList.update { currentList ->
                            currentList + product
                        }
                    }
                }
            }

        }
    }
}
